package com.chaoyue.base.utils;

import cn.hutool.core.util.StrUtil;
import lombok.experimental.UtilityClass;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * * @Author caolj2
 *
 * @Description 字符串工具类
 * @Date 2019/10/16
 */
@UtilityClass
public class StrUtils extends StrUtil {

    private static Pattern NUMBER_PATTERN = Pattern.compile("^[-\\+]?[\\d]*$");

    /**
     * 转换为Double类型
     */
    public static Double toDouble(Object val) {
        if (val == null) {
            return 0D;
        }
        try {
            return Double.valueOf(trim(val.toString()));
        } catch (Exception e) {
            return 0D;
        }
    }

    /**
     * 转换为Float类型
     */
    public static Float toFloat(Object val) {
        return toDouble(val).floatValue();
    }

    /**
     * 转换为Long类型
     */
    public static Long toLong(Object val) {
        return toDouble(val).longValue();
    }

    /**
     * 转换为Integer类型
     */
    public static Integer toInteger(Object val) {
        return toLong(val).intValue();
    }


    /**
     * 转换为String类型
     */
    public static String toStrNull(Object val) {
        if (null == val) {
            return "";
        } else {
            return toString(val);
        }
    }

    /**
     * 检查字符串是否可以被忽略，可以被忽略的字符串为null、空白串、“null”、“undefined”
     *
     * @param str 被检查的字符串
     * @return 是否为被忽略的字符串
     * @since 4.0.10
     */
    public static boolean isIgnore(CharSequence str) {
        return isBlankOrUndefined(str);
    }

    /**
     * 检查字符串是否不能被忽略
     *
     * @param str 被检查的字符串
     * @return 是否为不能被忽略的字符串
     * @since 4.0.10
     */
    public static boolean isNotIgnore(CharSequence str) {
        return false == isIgnore(str);
    }

    /**
     * 获取Guid
     *
     * @return Guid字符串
     * @since 4.0.10
     */
    public static String guid() {
        return UUID.randomUUID().toString().toLowerCase().replaceAll("-", "");
    }

    /**
     * @return toString 兼容null
     * @since 4.0.10
     */
    public static String toString(Object target) {
        return target == null ? "" : target.toString();
    }

    /**
     * @return toStringZero 兼容null
     * @since 4.0.10
     */
    public static String toStringZero(Object target) {
        return target == null ? "0" : target.toString();
    }

    /**
     * @return indexOfAny
     * @since 4.0.10
     */
    public static int indexOfAny(String target, char[] charArray) {
        int result = -1;
        for (char ch : charArray) {
            if (result == -1) {
                result = target.indexOf(ch);
            } else {
                int index = target.indexOf(ch);
                if (result > index && index != -1) {
                    result = index;
                }
            }
        }
        return result;
    }

    /**
     * @return 字符串分割
     * @since 4.0.10
     */
    public static String[] split(String target, String regex) {
        List<String> list = Arrays.stream(target.split(regex)).filter(t -> StrUtils.isNotIgnore(t)).collect(Collectors.toList());
        String[] result = new String[list.size()];
        list.toArray(result);
        return result;
    }

    /*
     * 判断是否为整数
     * @param str 传入的字符串
     * @return 是整数返回true,否则返回false
     */
    public static boolean isInteger(String str) {
        if (isNotBlank(str)) {
            return NUMBER_PATTERN.matcher(str).matches();
        } else {
            return false;
        }

    }

    /*
     * 判断是否为数字类型
     * @param str 传入的字符串
     * @return 是整数返回true,否则返回false
     */
    public static boolean isNumber(String str) {
        if (isNotBlank(str)) {
            if (str.trim().contains(".")) {
                return str.matches("-?[0-9]+.?[0-9]*");
            } else {
                return isInteger(str);
            }
        }
        {
            return false;
        }

    }

    /**
     * 字符串根据长度转成字符串数组
     *
     * @param str
     * @param subLen
     * @return
     */
    public static List<String> stringToList(String str, int subLen) {
        if (StrUtils.isBlank(str)) {
            return new ArrayList<>();
        }
        int length = str.length();
        int tempSub = 0;
        List<String> list = new ArrayList<>();
        for (int i = 0; tempSub < length; i++) {
            String strTemp = "";
            if (tempSub + subLen > length) {
                strTemp = str.substring(tempSub, length);
                list.add(strTemp);
                break;
            } else {
                strTemp = str.substring(tempSub, tempSub + subLen);
                list.add(strTemp);
            }
            tempSub += subLen;
        }
        return list;
    }

    public static String keyFormat(String... keys) {
        return String.join("#", keys);
    }

    public static String keyFormat(List<String> list) {
        return String.join("#", list);
    }

}
